package org.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Other {
    // 830. 较大分组的位置
    // 在一个由小写字母构成的字符串 s 中，包含由一些连续的相同字符所构成的分组。
    // 例如，在字符串 s = "abbxxxxzyy" 中，就含有 "a", "bb", "xxxx", "z" 和 "yy" 这样的一些分组。
    // 分组可以用区间 [start, end] 表示，其中 start 和 end 分别表示该分组的起始和终止位置的下标。上例中的 "xxxx" 分组用区间表示为 [3,6] 。
    // 我们称所有包含大于或等于三个连续字符的分组为 较大分组 。
    // 找到每一个 较大分组 的区间，按起始位置下标递增顺序排序后，返回结果。
    // 示例 1：
    // 输入：s = "abbxxxxzzy"
    // 输出：[[3,6]]
    // 解释："xxxx" 是一个起始于 3 且终止于 6 的较大分组。
    // 示例 2：
    // 输入：s = "abc"
    // 输出：[]
    // 解释："a","b" 和 "c" 均不是符合要求的较大分组。
    // 示例 3：
    // 输入：s = "abcdddeeeeaabbbcd"
    // 输出：[[3,5],[6,9],[12,14]]
    // 解释：较大分组为 "ddd", "eeee" 和 "bbb"
    // 示例 4：
    //
    // 输入：s = "aba"
    // 输出：[]

    static class LargeGroupPositions {
        public List<List<Integer>> largeGroupPositions(String s) {
            List<List<Integer>> ret = new ArrayList<>();
            int n = s.length();
            int num = 1;
            for (int i = 0; i < n; i++) {
                if (i == n - 1 || s.charAt(i) != s.charAt(i + 1)) {
                    if (num >= 3) {
                        ret.add(Arrays.asList(i - num + 1, i));
                    }
                    num = 1;
                } else {
                    num++;
                }
            }
            return ret;
        }
    }

    // 2138. 将字符串拆分为若干长度为 k 的组
    // 字符串 s 可以按下述步骤划分为若干长度为 k 的组：
    //第一组由字符串中的前 k 个字符组成，第二组由接下来的 k 个字符串组成，依此类推。每个字符都能够成为 某一个 组的一部分。
    //对于最后一组，如果字符串剩下的字符 不足 k 个，需使用字符 fill 来补全这一组字符。
    //注意，在去除最后一个组的填充字符 fill（如果存在的话）并按顺序连接所有的组后，所得到的字符串应该是 s 。
    //给你一个字符串 s ，以及每组的长度 k 和一个用于填充的字符 fill ，按上述步骤处理之后，返回一个字符串数组，该数组表示 s 分组后 每个组的组成情况 。
    //示例 1：
    //输入：s = "abcdefghi", k = 3, fill = "x"
    //输出：["abc","def","ghi"]
    //解释：
    //前 3 个字符是 "abc" ，形成第一组。
    //接下来 3 个字符是 "def" ，形成第二组。
    //最后 3 个字符是 "ghi" ，形成第三组。
    //由于所有组都可以由字符串中的字符完全填充，所以不需要使用填充字符。
    //因此，形成 3 组，分别是 "abc"、"def" 和 "ghi" 。
    //示例 2：
    //输入：s = "abcdefghij", k = 3, fill = "x"
    //输出：["abc","def","ghi","jxx"]
    //解释：
    //与前一个例子类似，形成前三组 "abc"、"def" 和 "ghi" 。
    //对于最后一组，字符串中仅剩下字符 'j' 可以用。为了补全这一组，使用填充字符 'x' 两次。
    //因此，形成 4 组，分别是 "abc"、"def"、"ghi" 和 "jxx" 。

    static class DivideString {
        public String[] divideString(String s, int k, char fill) {
            List<String> res = new ArrayList<>(); // 分组后的字符串
            int n = s.length();
            int curr = 0; // 每个分组的起始下标
            // 拆分字符串
            while (curr < n) {
                // 这行代码确定了当前分组的结束下标。其中，curr + k代表理想状态下分组的结束位置，但为了防止下标越界，
                // 就取curr + k和字符串长度n中的较小值。
                // 当curr + k ≤ n时，意味着能够完整地截取长度为k的子串，此时end的值就是curr + k。
                // 当curr + k > n时，说明已经到了字符串的末尾，无法再截取长度为k的子串，这时end的值为n，截取的是从curr到n-1的剩余字符。
                int end = Math.min(curr + k, n);
                res.add(s.substring(curr, end));
                curr += k;
            }
            // 尝试填充最后一组
            String last = res.get(res.size() - 1);
            if (last.length() < k) {
                last += String.valueOf(fill).repeat(k - last.length());
                res.set(res.size() - 1, last);
            }
            return res.toArray(new String[0]);
        }
    }

}
